

//多态：当父类引用 引用的对象不一样的时候表现出的行为是不一样的
//重写需要注意的点：
//1.private修饰的方法不能被重写的
//2.static修饰的方法是不能被重写的
//3.子类的访问修饰限定权限 要大于等于父类的权限
//private < 默认 < protected < public
//4.被final修饰的方法是不能被重写的 此时这个方法被称作 密封方法

class Animal {
    public String name;
    public int age;

    public void eat() {
        System.out.println(name + " 正在吃饭");
    }
}

class Dog extends Animal {

    public void wangwang() {
        System.out.println(name + " 正在汪汪叫");
    }
    public void eat() {
        System.out.println(name + " 正在吃狗粮");//方法的重写
    }

}
class Bird extends Animal {
    public String wing;

    public void fly() {
        System.out.println(name + " 正在飞");
    }

    @Override//这个注解的意思是，当前这个方法是被重写的
    public void eat() {
        System.out.println(name + " 正在吃鸟粮");//方法的重写
    }
}
public class Test2 {

    public static void main(String[] args) {
        Animal animal = new Dog();//向上转型
        //向下转型(非常不安全）
        Dog dog = (Dog) animal;
        dog.name = "haha";
        dog.wangwang();
    }


    //3种向上转型
    public static void func(Animal animal) {
        //向上转型---方法的传参
    }

    public static Animal func2() {
        //向上转型---方法的返回值
        return  new Dog();
    }
    public static void main3(String[] args) {
        Dog dog = new Dog();
        func(dog);//向上转型---方法的传参
    }

    public static void main2(String[] args) {

        Animal animal1 = new Dog();
        animal1.name = "十三月";
        animal1.eat();
        //animal1.wangwang();//error  因为父类没有这个方法
        //当我们发生向上转型之后，此时通过父类的应用智能访问父类自己的成员。不能访问到子类特有的成员
    }

    public static void main1(String[] args) {
        Dog dog = new Dog();
        dog.name = "十三月";
        dog.eat();
        dog.wangwang();

        Animal animal = dog;//向上转型---直接赋值

        Bird bird = new Bird();
        bird.name = "lala";
        Animal animal2 = bird;//向上转型

    }

}
